package utils;

import burp.api.montoya.http.message.requests.HttpRequest;
import ui.InterceptFilterPanel;

import java.util.List;
import java.util.concurrent.TimeoutException;
import java.util.regex.PatternSyntaxException;

public class InterceptFilterUtil {

    /**
     * 检查请求是否匹配拦截过滤器规则
     *
     * @param request 请求
     * @param rules 拦截过滤器规则列表
     * @return 是否匹配
     */
    public static boolean matchesInterceptFilterRules(HttpRequest request, List<InterceptFilterPanel.Rule> rules) {
        if (request == null) {
            return false;
        }

        if (rules == null || rules.isEmpty()) {
            return true; // 如果没有规则，则默认匹配所有请求
        }

        // 拦截过滤器规则逻辑关系固定为And
        for (InterceptFilterPanel.Rule rule : rules) {
            if (!matchesInterceptFilterRule(request, rule)) {
                return false; // 任一规则不匹配则返回false
            }
        }

        return true; // 所有规则都匹配
    }

    /**
     * 检查请求是否匹配单个拦截过滤器规则
     *
     * @param request 请求
     * @param rule 规则
     * @return 是否匹配
     */
    private static boolean matchesInterceptFilterRule(HttpRequest request, InterceptFilterPanel.Rule rule) {
        String ruleType = rule.getType();
        String ruleContent = rule.getContent();

        try {
            if ("URL 包含（字符串）".equals(ruleType)) {
                return request.url().contains(ruleContent);
            } else if ("URL 包含（正则）".equals(ruleType)) {
                return RegexUtil.safeRegexMatch(ruleContent, request.url());
            } else if ("URL 不包含（字符串）".equals(ruleType)) {
                return !request.url().contains(ruleContent);
            } else if ("URL 不包含（正则）".equals(ruleType)) {
                return !RegexUtil.safeRegexMatch(ruleContent, request.url());
            } else if ("请求方法包含（字符串，逗号分隔）".equals(ruleType)) {
                String[] methods = ruleContent.split(",");
                for (String method : methods) {
                    if (request.method().equalsIgnoreCase(method.trim())) {
                        return true;
                    }
                }
                return false;
            } else if ("请求方法不包含（字符串，逗号分隔）".equals(ruleType)) {
                String[] methods = ruleContent.split(",");
                for (String method : methods) {
                    if (request.method().equalsIgnoreCase(method.trim())) {
                        return false;
                    }
                }
                return true;
            }
        } catch (PatternSyntaxException e) {
            // 正则表达式语法错误
            LoggerUtil.logError("拦截过滤器正则表达式语法错误: " + e.getMessage());
            return false;
        } catch (NumberFormatException e) {
            // 数字格式错误
            LoggerUtil.logError("拦截过滤器数字格式错误: " + e.getMessage());
            return false;
        } catch (TimeoutException e) {
            // 正则表达式匹配超时
            LoggerUtil.logError("拦截过滤器正则表达式匹配超时: " + e.getMessage());
            return false;
        } catch (Exception e) {
            // 其他异常
            LoggerUtil.logError("拦截过滤器规则评估过程中发生未知错误: " + e.getMessage());
            return false;
        }

        return false; // 未知规则类型，默认不匹配
    }

    /**
     * 关闭正则表达式执行器
     */
    public static void shutdownRegexExecutor() {
        RegexUtil.shutdownRegexExecutor();
    }
}
